#ifndef SYNTAX_TREE_H
#define SYNTAX_TREE_H

#include "generic_table.h"

// List of all productions in GPSS++ grammar.
// The first element is not representation of any production. It is used to
// describe AST node which contains terminal symbol. 
// There are 2 special terminal symbols: endOfFile and endOfProject. These terminals
// are added to uniform table by Lexic analyzer. They can not be found in gpss++
// source code.
enum Grammar {
	// Terminal symbol
	Gr_Terminal,

	// <program_body> ~ <gpp_file> <program_body>  {endOfFile, using, simulation, namespace, enum, class, model, numeric, template, public, private, start, process, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, trace, abstract, protected, final, virtual, override, static, const}
	Gr_ProgramBody__GppFile_ProgramBody,

	// <program_body> ~ endOfProject  {endOfProject}
	Gr_ProgramBody__endOfProject,

	// <gpp_file> ~ <using_directives> <file_body> endOfFile  {using, simulation, namespace, enum, class, model, numeric, template, public, private, start, process, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, trace, abstract, protected, final, virtual, override, static, const, endOfFile}
	Gr_GppFile__UsingDirectives_FileBody_endOfFile,

	// <using_directives> ~ <using_directive> <using_directives>  {using}
	Gr_UsingDirectives__UsingDirective_UsingDirectives,

	// <using_directives> ~ ? {simulation, namespace, enum, class, model, numeric, template, public, private, start, process, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, trace, abstract, protected, final, virtual, override, static, const, endOfFile, }, define, generate, terminate, advance, enter, leave, seize, release, inqueue, outqueue, arrive, depart, goto, if, wait, join, create, split, gather, execute, exec}
	Gr_UsingDirectives__epsilon,

	// <using_directive> ~ using <name> ;  {using}
	Gr_UsingDirective__using_Name_spSemiCol,

	// <using_directive> ~ using <name> as NAME ;  {using}
	Gr_UsingDirective__using_Name_as_NAME_spSemiCol,

	// <file_body> ~ <main_definition> <file_body>  {namespace, enum, class, model, numeric, template, public, private, start, process, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, trace, abstract, protected, final, virtual, override, static, const}
	Gr_FileBody__MainDefinition_FileBody,

	// <file_body> ~ <simulation> <file_body>  {simulation}
	Gr_FileBody__Simulation_FileBody,

	// <file_body> ~ ? {endOfFile, }}
	Gr_FileBody__epsilon,

	// <main_definition> ~ <namespace_definition>  {namespace}
	Gr_MainDefinition__NamespaceDefinition,

	// <main_definition> ~ <enum_definition>  {enum}
	Gr_MainDefinition__EnumDefinition,

	// <main_definition> ~ <class_definition>  {class, template, abstract, public, private, protected, final}
	Gr_MainDefinition__ClassDefinition,

	// <main_definition> ~ <model_definition>  {model, public, private}
	Gr_MainDefinition__ModelDefinition,

	// <main_definition> ~ <method_definition>  {numeric, start, process, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, abstract, virtual, public, private, protected, override, static, final}
	Gr_MainDefinition__MethodDefinition,

	// <main_definition> ~ <field_definition>  {trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, const, public, private, protected, static}
	Gr_MainDefinition__FieldDefinition,

	// <main_definition> ~ <property_definition>  {int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, public, protected, private, static, abstract, override, virtual, final}
	Gr_MainDefinition__PropertyDefinition,

	// <namespace_definition> ~ namespace <name> { <using_directives> <file_body> }  {namespace}
	Gr_NamespaceDefinition__namespace_Name_spLCBrac_UsingDirectives_FileBody_spRCBrac,

	// <data_type> ~ <name> <template_use>  {NAME}
	Gr_DataType__Name_TemplateUse,

	// <data_type> ~ <name>  {NAME}
	Gr_DataType__Name,

	// <data_type> ~ int  {int}
	Gr_DataType__int,

	// <data_type> ~ float  {float}
	Gr_DataType__float,

	// <data_type> ~ bool  {bool}
	Gr_DataType__bool,

	// <data_type> ~ state  {state}
	Gr_DataType__state,

	// <data_type> ~ time  {time}
	Gr_DataType__time,

	// <data_type> ~ void  {void}
	Gr_DataType__void,

	// <data_type> ~ Facility  {Facility}
	Gr_DataType__Facility,

	// <data_type> ~ Storage  {Storage}
	Gr_DataType__Storage,

	// <data_type> ~ Queue  {Queue}
	Gr_DataType__Queue,

	// <data_type> ~ ADTable  {ADTable}
	Gr_DataType__ADTable,

	// <data_type> ~ Group  {Group}
	Gr_DataType__Group,

	// <data_type> ~ OutputStream  {OutputStream}
	Gr_DataType__OutputStream,

	// <enum_definition> ~ enum NAME { <enum_names> }  {enum}
	Gr_EnumDefinition__enum_NAME_spLCBrac_EnumNames_spRCBrac,

	// <enum_names> ~ NAME <enum_names_add>  {NAME}
	Gr_EnumNames__NAME_EnumNamesAdd,

	// <name_comma_add> ~ , NAME  {,}
	Gr_NameCommaAdd__spComma_NAME,

	// <enum_names_add> ~ <name_comma_add> <enum_names_add>  {,}
	Gr_EnumNamesAdd__NameCommaAdd_EnumNamesAdd,

	// <enum_names_add> ~ ? {}}
	Gr_EnumNamesAdd__epsilon,

	// <class_definition> ~ <class_mods> <template_definition> class NAME <class_inherit> { <using_directives> <class_body_add> }  {abstract, public, private, protected, final, template, class}
	Gr_ClassDefinition__ClassMods_TemplateDefinition_class_NAME_ClassInherit_spLCBrac_UsingDirectives_ClassBodyAdd_spRCBrac,

	// <class_mods> ~ <class_mod> <class_mods>  {abstract, public, private, protected, final}
	Gr_ClassMods__ClassMod_ClassMods,

	// <class_mods> ~ ? {template, class}
	Gr_ClassMods__epsilon,

	// <class_mod> ~ abstract  {abstract}
	Gr_ClassMod__abstract,

	// <class_mod> ~ public  {public}
	Gr_ClassMod__public,

	// <class_mod> ~ private  {private}
	Gr_ClassMod__private,

	// <class_mod> ~ protected  {protected}
	Gr_ClassMod__protected,

	// <class_mod> ~ final  {final}
	Gr_ClassMod__final,

	// <template_definition> ~ template <template_use>  {template}
	Gr_TemplateDefinition__template_TemplateUse,

	// <template_definition> ~ ? {class}
	Gr_TemplateDefinition__epsilon,

	// <template_use> ~ < <templates_list> >  {<}
	Gr_TemplateUse__opLess_TemplatesList_opGreat,

	// <templates_list> ~ NAME <templates_list_add>  {NAME}
	Gr_TemplatesList__NAME_TemplatesListAdd,

	// <templates_list_add> ~ <name_comma_add> <templates_list_add>  {,}
	Gr_TemplatesListAdd__NameCommaAdd_TemplatesListAdd,

	// <templates_list_add> ~ ? {>}
	Gr_TemplatesListAdd__epsilon,

	// <class_inherit> ~ : <class_inherit_name>  {:}
	Gr_ClassInherit__spColon_ClassInheritName,

	// <class_inherit> ~ ? {{}
	Gr_ClassInherit__epsilon,

	// <class_inherit_name> ~ <name> <template_use>  {NAME}
	Gr_ClassInheritName__Name_TemplateUse,

	// <class_inherit_name> ~ <name>  {NAME}
	Gr_ClassInheritName__Name,

	// <class_body_add> ~ <class_body> <class_body_add>  {NAME, numeric, enum, class, template, public, private, protected, trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, start, process, abstract, final, const, static, virtual, override}
	Gr_ClassBodyAdd__ClassBody_ClassBodyAdd,

	// <class_body_add> ~ ? {}}
	Gr_ClassBodyAdd__epsilon,

	// <class_body> ~ <constructor_definition>  {NAME, public, private, protected}
	Gr_ClassBody__ConstructorDefinition,

	// <class_body> ~ <field_definition>  {trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, const, public, private, protected, static}
	Gr_ClassBody__FieldDefinition,

	// <class_body> ~ <method_definition>  {numeric, start, process, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, abstract, virtual, public, private, protected, override, static, final}
	Gr_ClassBody__MethodDefinition,

	// <class_body> ~ <property_definition>  {int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, public, protected, private, static, abstract, override, virtual, final}
	Gr_ClassBody__PropertyDefinition,

	// <class_body> ~ <enum_definition>  {enum}
	Gr_ClassBody__EnumDefinition,

	// <class_body> ~ <class_definition>  {class, template, abstract, public, private, protected, final}
	Gr_ClassBody__ClassDefinition,

	// <constructor_definition> ~ <constr_mod> NAME ( <parameters> ) <constr_inherit> <constr_body>  {public, private, protected, NAME}
	Gr_ConstructorDefinition__ConstrMod_NAME_spLPar_Parameters_spRPar_ConstrInherit_ConstrBody,

	// <constr_mod> ~ public  {public}
	Gr_ConstrMod__public,

	// <constr_mod> ~ private  {private}
	Gr_ConstrMod__private,

	// <constr_mod> ~ protected  {protected}
	Gr_ConstrMod__protected,

	// <constr_mod> ~ ? {NAME}
	Gr_ConstrMod__epsilon,

	// <constr_inherit> ~ : <name> ( <arguments> )  {:}
	Gr_ConstrInherit__spColon_Name_spLPar_Arguments_spRPar,

	// <constr_inherit> ~ ? {;, {}
	Gr_ConstrInherit__epsilon,

	// <constr_body> ~ ;  {;}
	Gr_ConstrBody__spSemiCol,

	// <constr_body> ~ { <method_body> }  {{}
	Gr_ConstrBody__spLCBrac_MethodBody_spRCBrac,

	// <field_definition> ~ <field_mods> <trace_part> <data_type> <field_names> ;  {const, public, private, protected, static, trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_FieldDefinition__FieldMods_TracePart_DataType_FieldNames_spSemiCol,

	// <field_mods> ~ <field_mod> <field_mods>  {const, public, private, protected, static}
	Gr_FieldMods__FieldMod_FieldMods,

	// <field_mods> ~ ? {trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_FieldMods__epsilon,

	// <field_mod> ~ const  {const}
	Gr_FieldMod__const,

	// <field_mod> ~ public  {public}
	Gr_FieldMod__public,

	// <field_mod> ~ private  {private}
	Gr_FieldMod__private,

	// <field_mod> ~ protected  {protected}
	Gr_FieldMod__protected,

	// <field_mod> ~ static  {static}
	Gr_FieldMod__static,

	// <field_names> ~ <field_name> <equals> <field_names_add>  {NAME}
	Gr_FieldNames__FieldName_Equals_FieldNamesAdd,

	// <field_name> ~ NAME <array_definitions>  {NAME}
	Gr_FieldName__NAME_ArrayDefinitions,

	// <field_names_add> ~ , <field_names>  {,}
	Gr_FieldNamesAdd__spComma_FieldNames,

	// <field_names_add> ~ ? {;, )}
	Gr_FieldNamesAdd__epsilon,

	// <equals> ~ = <expression>  {=}
	Gr_Equals__opAssign_Expression,

	// <equals> ~ ? {,, ;, )}
	Gr_Equals__epsilon,

	// <array_definitions> ~ <array_definition> <array_definitions>  {[}
	Gr_ArrayDefinitions__ArrayDefinition_ArrayDefinitions,

	// <array_definitions> ~ ? {=, ,, ;, )}
	Gr_ArrayDefinitions__epsilon,

	// <array_definition> ~ [ ]  {[}
	Gr_ArrayDefinition__spLSBrac_spRSBrac,

	// <property_definition> ~ <property_mods> <data_type> <property_name>  {public, protected, private, static, abstract, override, virtual, final, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_PropertyDefinition__PropertyMods_DataType_PropertyName,

	// <property_mods> ~ <property_mod> <property_mods>  {public, protected, private, static, abstract, override, virtual, final}
	Gr_PropertyMods__PropertyMod_PropertyMods,

	// <property_mods> ~ ? {int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_PropertyMods__epsilon,

	// <property_mod> ~ public  {public}
	Gr_PropertyMod__public,

	// <property_mod> ~ protected  {protected}
	Gr_PropertyMod__protected,

	// <property_mod> ~ private  {private}
	Gr_PropertyMod__private,

	// <property_mod> ~ static  {static}
	Gr_PropertyMod__static,

	// <property_mod> ~ abstract  {abstract}
	Gr_PropertyMod__abstract,

	// <property_mod> ~ override  {override}
	Gr_PropertyMod__override,

	// <property_mod> ~ virtual  {virtual}
	Gr_PropertyMod__virtual,

	// <property_mod> ~ final  {final}
	Gr_PropertyMod__final,

	// <property_name> ~ NAME <prop_array_defs> <property_body>  {NAME}
	Gr_PropertyName__NAME_PropArrayDefs_PropertyBody,

	// <prop_array_defs> ~ <prop_array_def> <prop_array_defs>  {[}
	Gr_PropArrayDefs__PropArrayDef_PropArrayDefs,

	// <prop_array_defs> ~ ? {{}
	Gr_PropArrayDefs__epsilon,

	// <prop_array_def> ~ [ int NAME ]  {[}
	Gr_PropArrayDef__spLSBrac_int_NAME_spRSBrac,

	// <property_body> ~ { <property_read> <property_write> }  {{}
	Gr_PropertyBody__spLCBrac_PropertyRead_PropertyWrite_spRCBrac,

	// <property_body> ~ { <property_write> <property_read> }  {{}
	Gr_PropertyBody__spLCBrac_PropertyWrite_PropertyRead_spRCBrac,

	// <property_read> ~ read { <method_body> }  {read}
	Gr_PropertyRead__read_spLCBrac_MethodBody_spRCBrac,

	// <property_read> ~ ? {write, }}
	Gr_PropertyRead__epsilon,

	// <property_write> ~ write { <method_body> }  {write}
	Gr_PropertyWrite__write_spLCBrac_MethodBody_spRCBrac,

	// <property_write> ~ ? {}, read}
	Gr_PropertyWrite__epsilon,

	// <method_definition> ~ <method_mods> <start_process> <data_type> NAME ( <parameters> ) <method_body_decl>  {abstract, virtual, public, private, protected, override, static, final, start, process, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_MethodDefinition__MethodMods_StartProcess_DataType_NAME_spLPar_Parameters_spRPar_MethodBodyDecl,

	// <method_definition> ~ <method_mods> numeric <numeric_mod> <data_type> NAME ( <parameters> ) { <inf_begin> <value_pairs> <inf_end> }  {abstract, virtual, public, private, protected, override, static, final, numeric}
	Gr_MethodDefinition__MethodMods_numeric_NumericMod_DataType_NAME_spLPar_Parameters_spRPar_spLCBrac_InfBegin_ValuePairs_InfEnd_spRCBrac,

	// <method_mods> ~ <method_mod> <method_mods>  {abstract, virtual, public, private, protected, override, static, final}
	Gr_MethodMods__MethodMod_MethodMods,

	// <method_mods> ~ ? {start, process, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, numeric}
	Gr_MethodMods__epsilon,

	// <method_mod> ~ abstract  {abstract}
	Gr_MethodMod__abstract,

	// <method_mod> ~ virtual  {virtual}
	Gr_MethodMod__virtual,

	// <method_mod> ~ public  {public}
	Gr_MethodMod__public,

	// <method_mod> ~ private  {private}
	Gr_MethodMod__private,

	// <method_mod> ~ protected  {protected}
	Gr_MethodMod__protected,

	// <method_mod> ~ override  {override}
	Gr_MethodMod__override,

	// <method_mod> ~ static  {static}
	Gr_MethodMod__static,

	// <method_mod> ~ final  {final}
	Gr_MethodMod__final,

	// <start_process> ~ start process  {start}
	Gr_StartProcess__start_process,

	// <start_process> ~ process  {process}
	Gr_StartProcess__process,

	// <start_process> ~ ? {int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_StartProcess__epsilon,

	// <method_body_decl> ~ ;  {;}
	Gr_MethodBodyDecl__spSemiCol,

	// <method_body_decl> ~ { <method_body> }  {{}
	Gr_MethodBodyDecl__spLCBrac_MethodBody_spRCBrac,

	// <method_body> ~ <label_method_statement> <method_body>  {NAME, if, while, for, do, switch, break, continue, return, goto, start, stop, derivation, {, trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, }}
	Gr_MethodBody__LabelMethodStatement_MethodBody,

	// <method_body> ~ ? {}}
	Gr_MethodBody__epsilon,

	// <label_method_statement> ~ <method_labels> <method_statement>  {NAME, if, while, for, do, switch, break, continue, return, goto, start, stop, derivation, {, trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, }}
	Gr_LabelMethodStatement__MethodLabels_MethodStatement,

	// <method_labels> ~ <label> <method_labels>  {NAME}
	Gr_MethodLabels__Label_MethodLabels,

	// <method_labels> ~ ? {NAME, if, while, for, do, switch, break, continue, return, goto, start, stop, derivation, {, trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, }}
	Gr_MethodLabels__epsilon,

	// <label> ~ NAME :  {NAME}
	Gr_Label__NAME_spColon,

	// <method_statement> ~ <variable_definition>  {trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_MethodStatement__VariableDefinition,

	// <method_statement> ~ <assignment>  {NAME}
	Gr_MethodStatement__Assignment,

	// <method_statement> ~ <method_call>  {NAME}
	Gr_MethodStatement__MethodCall,

	// <method_statement> ~ <if_statement>  {if}
	Gr_MethodStatement__IfStatement,

	// <method_statement> ~ <while_statement>  {while}
	Gr_MethodStatement__WhileStatement,

	// <method_statement> ~ <for_statement>  {for}
	Gr_MethodStatement__ForStatement,

	// <method_statement> ~ <dowhile_statement>  {do}
	Gr_MethodStatement__DowhileStatement,

	// <method_statement> ~ <switch_case_statement>  {switch}
	Gr_MethodStatement__SwitchCaseStatement,

	// <method_statement> ~ <break_statement>  {break}
	Gr_MethodStatement__BreakStatement,

	// <method_statement> ~ <continue_statement>  {continue}
	Gr_MethodStatement__ContinueStatement,

	// <method_statement> ~ <return_statement>  {return}
	Gr_MethodStatement__ReturnStatement,

	// <method_statement> ~ <goto_statement>  {goto}
	Gr_MethodStatement__GotoStatement,

	// <method_statement> ~ <start_statement>  {start}
	Gr_MethodStatement__StartStatement,

	// <method_statement> ~ <stop_statement>  {stop}
	Gr_MethodStatement__StopStatement,

	// <method_statement> ~ <assignment_derivation>  {derivation}
	Gr_MethodStatement__AssignmentDerivation,

	// <method_statement> ~ <block_statement>  {{}
	Gr_MethodStatement__BlockStatement,

	// <method_statement> ~ ? {NAME, if, while, for, do, switch, break, continue, return, goto, start, stop, derivation, {, trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, }}
	Gr_MethodStatement__epsilon,

	// <parameters> ~ <parameter> <parameters_add>  {int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_Parameters__Parameter_ParametersAdd,

	// <parameters> ~ ? {)}
	Gr_Parameters__epsilon,

	// <parameter_comma_add> ~ , <parameter>  {,}
	Gr_ParameterCommaAdd__spComma_Parameter,

	// <parameters_add> ~ <parameter_comma_add> <parameters_add>  {,}
	Gr_ParametersAdd__ParameterCommaAdd_ParametersAdd,

	// <parameters_add> ~ ? {)}
	Gr_ParametersAdd__epsilon,

	// <parameter> ~ <data_type> NAME <array_definitions>  {int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_Parameter__DataType_NAME_ArrayDefinitions,

	// <arguments> ~ <expression> <arguments_add>  {!, -, +, LITERAL, null, new, NAME, (}
	Gr_Arguments__Expression_ArgumentsAdd,

	// <arguments> ~ ? {)}
	Gr_Arguments__epsilon,

	// <argument_comma_add> ~ , <expression>  {,}
	Gr_ArgumentCommaAdd__spComma_Expression,

	// <arguments_add> ~ <argument_comma_add> <arguments_add>  {,}
	Gr_ArgumentsAdd__ArgumentCommaAdd_ArgumentsAdd,

	// <arguments_add> ~ ? {)}
	Gr_ArgumentsAdd__epsilon,

	// <variable_definition> ~ <trace_part> <data_type> <field_names> ;  {trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_VariableDefinition__TracePart_DataType_FieldNames_spSemiCol,

	// <trace_part> ~ trace <numeric_mod> ( <arguments> )  {trace}
	Gr_TracePart__trace_NumericMod_spLPar_Arguments_spRPar,

	// <trace_part> ~ trace <numeric_mod>  {trace}
	Gr_TracePart__trace_NumericMod,

	// <trace_part> ~ ? {int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_TracePart__epsilon,

	// <assignment> ~ <variable_value> = <expression> ;  {NAME}
	Gr_Assignment__VariableValue_opAssign_Expression_spSemiCol,

	// <method_call> ~ NAME ( <arguments> ) ;  {NAME}
	Gr_MethodCall__NAME_spLPar_Arguments_spRPar_spSemiCol,

	// <method_call> ~ <variable_value> . NAME ( <arguments> ) ;  {NAME}
	Gr_MethodCall__VariableValue_spPer_NAME_spLPar_Arguments_spRPar_spSemiCol,

	// <if_statement> ~ if ( <expression> ) <block_statement> <else_part>  {if}
	Gr_IfStatement__if_spLPar_Expression_spRPar_BlockStatement_ElsePart,

	// <block_statement> ~ { <method_body> }  {{}
	Gr_BlockStatement__spLCBrac_MethodBody_spRCBrac,

	// <else_part> ~ else <block_statement>  {else}
	Gr_ElsePart__else_BlockStatement,

	// <else_part> ~ ? {NAME, if, while, for, do, switch, break, continue, return, goto, start, stop, derivation, {, trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, }}
	Gr_ElsePart__epsilon,

	// <switch_case_statement> ~ switch ( <expression> ) { <switch_case_cases> <switch_case_default> }  {switch}
	Gr_SwitchCaseStatement__switch_spLPar_Expression_spRPar_spLCBrac_SwitchCaseCases_SwitchCaseDefault_spRCBrac,

	// <switch_case_cases> ~ <switch_case_case> <switch_case_cases>  {case}
	Gr_SwitchCaseCases__SwitchCaseCase_SwitchCaseCases,

	// <switch_case_cases> ~ ? {default, }}
	Gr_SwitchCaseCases__epsilon,

	// <switch_case_case> ~ case <expression> : <block_statement>  {case}
	Gr_SwitchCaseCase__case_Expression_spColon_BlockStatement,

	// <switch_case_default> ~ default : <block_statement>  {default}
	Gr_SwitchCaseDefault__default_spColon_BlockStatement,

	// <switch_case_default> ~ ? {}}
	Gr_SwitchCaseDefault__epsilon,

	// <while_statement> ~ while ( <expression> ) <block_statement>  {while}
	Gr_WhileStatement__while_spLPar_Expression_spRPar_BlockStatement,

	// <dowhile_statement> ~ do <block_statement> while ( <expression> ) ;  {do}
	Gr_DowhileStatement__do_BlockStatement_while_spLPar_Expression_spRPar_spSemiCol,

	// <for_statement> ~ for ( <simple_statement> ; <expression> ; <simple_statement> ) <block_statement>  {for}
	Gr_ForStatement__for_spLPar_SimpleStatement_spSemiCol_Expression_spSemiCol_SimpleStatement_spRPar_BlockStatement,

	// <simple_statement> ~ <data_type> <field_names>  {int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME}
	Gr_SimpleStatement__DataType_FieldNames,

	// <simple_statement> ~ <variable_value> = <expression>  {NAME}
	Gr_SimpleStatement__VariableValue_opAssign_Expression,

	// <simple_statement> ~ NAME ( <arguments> )  {NAME}
	Gr_SimpleStatement__NAME_spLPar_Arguments_spRPar,

	// <simple_statement> ~ <variable_value> . NAME ( <arguments> )  {NAME}
	Gr_SimpleStatement__VariableValue_spPer_NAME_spLPar_Arguments_spRPar,

	// <break_statement> ~ break ;  {break}
	Gr_BreakStatement__break_spSemiCol,

	// <continue_statement> ~ continue ;  {continue}
	Gr_ContinueStatement__continue_spSemiCol,

	// <goto_statement> ~ goto NAME ;  {goto}
	Gr_GotoStatement__goto_NAME_spSemiCol,

	// <return_statement> ~ return <expression> ;  {return}
	Gr_ReturnStatement__return_Expression_spSemiCol,

	// <return_statement> ~ return ;  {return}
	Gr_ReturnStatement__return_spSemiCol,

	// <start_statement> ~ start <name> ( <arguments> ) with <start_assignments> ;  {start}
	Gr_StartStatement__start_Name_spLPar_Arguments_spRPar_with_StartAssignments_spSemiCol,

	// <start_statement> ~ start <name> ( <arguments> ) ;  {start}
	Gr_StartStatement__start_Name_spLPar_Arguments_spRPar_spSemiCol,

	// <start_assignments> ~ <start_assignment> <start_assignment_add>  {NAME}
	Gr_StartAssignments__StartAssignment_StartAssignmentAdd,

	// <start_assignment_add> ~ <start_assignment_comma_add> <start_assignment_add>  {,}
	Gr_StartAssignmentAdd__StartAssignmentCommaAdd_StartAssignmentAdd,

	// <start_assignment_add> ~ ? {;}
	Gr_StartAssignmentAdd__epsilon,

	// <start_assignment_comma_add> ~ , <start_assignment>  {,}
	Gr_StartAssignmentCommaAdd__spComma_StartAssignment,

	// <start_assignment> ~ NAME = <expression>  {NAME}
	Gr_StartAssignment__NAME_opAssign_Expression,

	// <stop_statement> ~ stop <name> ;  {stop}
	Gr_StopStatement__stop_Name_spSemiCol,

	// <assignment_derivation> ~ derivation <variable_value> = <expression> ;  {derivation}
	Gr_AssignmentDerivation__derivation_VariableValue_opAssign_Expression_spSemiCol,

	// <numeric_mod> ~ discrete  {discrete}
	Gr_NumericMod__discrete,

	// <numeric_mod> ~ continuous  {continuous}
	Gr_NumericMod__continuous,

	// <inf_begin> ~ - INF ;  {-}
	Gr_InfBegin__opSub_INF_spSemiCol,

	// <inf_begin> ~ ? {LITERAL, +, -, ;, }}
	Gr_InfBegin__epsilon,

	// <inf_end> ~ ; + INF  {;}
	Gr_InfEnd__spSemiCol_opAdd_INF,

	// <inf_end> ~ ? {}}
	Gr_InfEnd__epsilon,

	// <value_pairs> ~ <value_pair> <value_pairs_adds>  {LITERAL, +, -}
	Gr_ValuePairs__ValuePair_ValuePairsAdds,

	// <value_pairs> ~ ? {;, }}
	Gr_ValuePairs__epsilon,

	// <value_pairs_adds> ~ ? {;, }}
	Gr_ValuePairsAdds__epsilon,

	// <value_pairs_adds> ~ <value_pair_add> <value_pairs_adds>  {;}
	Gr_ValuePairsAdds__ValuePairAdd_ValuePairsAdds,

	// <value_pair_add> ~ ; <value_pair>  {;}
	Gr_ValuePairAdd__spSemiCol_ValuePair,

	// <value_pair> ~ <sign_value> LITERAL -> <sign_value> LITERAL  {+, -, LITERAL}
	Gr_ValuePair__SignValue_LITERAL_spArrow_SignValue_LITERAL,

	// <sign_value> ~ +  {+}
	Gr_SignValue__opAdd,

	// <sign_value> ~ -  {-}
	Gr_SignValue__opSub,

	// <sign_value> ~ ? {LITERAL}
	Gr_SignValue__epsilon,

	// <model_definition> ~ <model_mod> model <name> ( <parameters> ) <model_definition_in> <model_definition_out> { <model_body> }  {public, private, model}
	Gr_ModelDefinition__ModelMod_model_Name_spLPar_Parameters_spRPar_ModelDefinitionIn_ModelDefinitionOut_spLCBrac_ModelBody_spRCBrac,

	// <model_definition_in> ~ in ( <label_list> )  {in}
	Gr_ModelDefinitionIn__in_spLPar_LabelList_spRPar,

	// <model_definition_in> ~ ? {out, {}
	Gr_ModelDefinitionIn__epsilon,

	// <model_definition_out> ~ out ( <label_list> )  {out}
	Gr_ModelDefinitionOut__out_spLPar_LabelList_spRPar,

	// <model_definition_out> ~ ? {{}
	Gr_ModelDefinitionOut__epsilon,

	// <label_list> ~ ? {)}
	Gr_LabelList__epsilon,

	// <label_list> ~ default <labels>  {default}
	Gr_LabelList__default_Labels,

	// <label_list> ~ NAME <labels>  {NAME}
	Gr_LabelList__NAME_Labels,

	// <labels> ~ <comma_label> <labels>  {,}
	Gr_Labels__CommaLabel_Labels,

	// <labels> ~ ? {)}
	Gr_Labels__epsilon,

	// <comma_label> ~ , NAME  {,}
	Gr_CommaLabel__spComma_NAME,

	// <model_mod> ~ public  {public}
	Gr_ModelMod__public,

	// <model_mod> ~ private  {private}
	Gr_ModelMod__private,

	// <model_mod> ~ ? {model}
	Gr_ModelMod__epsilon,

	// <model_body> ~ <using_directives> <model_define> <model_structure>  {using, define, NAME, generate, terminate, advance, enter, leave, seize, release, inqueue, outqueue, arrive, depart, model, goto, if, wait, join, create, split, gather, execute, exec, }}
	Gr_ModelBody__UsingDirectives_ModelDefine_ModelStructure,

	// <model_define> ~ define { <define_body_statements> }  {define}
	Gr_ModelDefine__define_spLCBrac_DefineBodyStatements_spRCBrac,

	// <model_define> ~ ? {NAME, generate, terminate, advance, enter, leave, seize, release, inqueue, outqueue, arrive, depart, model, goto, if, wait, join, create, split, gather, execute, exec, }}
	Gr_ModelDefine__epsilon,

	// <define_body_statements> ~ <define_body_statement> <define_body_statements>  {trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, numeric, start, process, enum, const, public, private, protected, static, abstract, override, virtual, final}
	Gr_DefineBodyStatements__DefineBodyStatement_DefineBodyStatements,

	// <define_body_statements> ~ ? {}}
	Gr_DefineBodyStatements__epsilon,

	// <define_body_statement> ~ <field_definition>  {trace, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, const, public, private, protected, static}
	Gr_DefineBodyStatement__FieldDefinition,

	// <define_body_statement> ~ <property_definition>  {int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, public, protected, private, static, abstract, override, virtual, final}
	Gr_DefineBodyStatement__PropertyDefinition,

	// <define_body_statement> ~ <method_definition>  {numeric, start, process, int, float, bool, state, time, void, Facility, Storage, Queue, ADTable, Group, OutputStream, NAME, abstract, virtual, public, private, protected, override, static, final}
	Gr_DefineBodyStatement__MethodDefinition,

	// <define_body_statement> ~ <enum_definition>  {enum}
	Gr_DefineBodyStatement__EnumDefinition,

	// <label_gpss_block> ~ <block_labels> <gpss_block>  {NAME, generate, terminate, advance, enter, leave, seize, release, inqueue, outqueue, arrive, depart, model, goto, if, wait, join, create, split, gather, execute, exec}
	Gr_LabelGpssBlock__BlockLabels_GpssBlock,

	// <model_structure> ~ <label_gpss_block> <model_structure>  {NAME, generate, terminate, advance, enter, leave, seize, release, inqueue, outqueue, arrive, depart, model, goto, if, wait, join, create, split, gather, execute, exec}
	Gr_ModelStructure__LabelGpssBlock_ModelStructure,

	// <model_structure> ~ ? {}}
	Gr_ModelStructure__epsilon,

	// <block_labels> ~ ? {generate, terminate, advance, enter, leave, seize, release, inqueue, outqueue, arrive, depart, model, goto, if, wait, join, create, split, gather, execute, exec, NAME}
	Gr_BlockLabels__epsilon,

	// <block_labels> ~ <block_label> <block_labels>  {NAME}
	Gr_BlockLabels__BlockLabel_BlockLabels,

	// <block_label> ~ NAME :  {NAME}
	Gr_BlockLabel__NAME_spColon,

	// <block_label> ~ NAME . NAME :  {NAME}
	Gr_BlockLabel__NAME_spPer_NAME_spColon,

	// <gpss_block> ~ <generate_block>  {generate}
	Gr_GpssBlock__GenerateBlock,

	// <gpss_block> ~ <terminate_block>  {terminate}
	Gr_GpssBlock__TerminateBlock,

	// <gpss_block> ~ <advance_block>  {advance}
	Gr_GpssBlock__AdvanceBlock,

	// <gpss_block> ~ <enter_block>  {enter}
	Gr_GpssBlock__EnterBlock,

	// <gpss_block> ~ <leave_block>  {leave}
	Gr_GpssBlock__LeaveBlock,

	// <gpss_block> ~ <seize_block>  {seize}
	Gr_GpssBlock__SeizeBlock,

	// <gpss_block> ~ <release_block>  {release}
	Gr_GpssBlock__ReleaseBlock,

	// <gpss_block> ~ <inqueue_block>  {inqueue}
	Gr_GpssBlock__InqueueBlock,

	// <gpss_block> ~ <outqueue_block>  {outqueue}
	Gr_GpssBlock__OutqueueBlock,

	// <gpss_block> ~ <arrive_block>  {arrive}
	Gr_GpssBlock__ArriveBlock,

	// <gpss_block> ~ <depart_block>  {depart}
	Gr_GpssBlock__DepartBlock,

	// <gpss_block> ~ <model_instance_block>  {model, NAME}
	Gr_GpssBlock__ModelInstanceBlock,

	// <gpss_block> ~ <goto_block>  {goto}
	Gr_GpssBlock__GotoBlock,

	// <gpss_block> ~ <if_block>  {if}
	Gr_GpssBlock__IfBlock,

	// <gpss_block> ~ <wait_block>  {wait}
	Gr_GpssBlock__WaitBlock,

	// <gpss_block> ~ <join_group_block>  {join}
	Gr_GpssBlock__JoinGroupBlock,

	// <gpss_block> ~ <leave_group_block>  {leave}
	Gr_GpssBlock__LeaveGroupBlock,

	// <gpss_block> ~ <create_block>  {create}
	Gr_GpssBlock__CreateBlock,

	// <gpss_block> ~ <split_block>  {split}
	Gr_GpssBlock__SplitBlock,

	// <gpss_block> ~ <gather_block>  {gather}
	Gr_GpssBlock__GatherBlock,

	// <gpss_block> ~ <execute_block>  {execute, exec}
	Gr_GpssBlock__ExecuteBlock,

	// <generate_block> ~ generate <upto_expression> <generate_transactions> <after_expression> <every_expression> ;  {generate}
	Gr_GenerateBlock__generate_UptoExpression_GenerateTransactions_AfterExpression_EveryExpression_spSemiCol,

	// <upto_expression> ~ upto <expression>  {upto}
	Gr_UptoExpression__upto_Expression,

	// <upto_expression> ~ ? {NAME, after, every, ;, send}
	Gr_UptoExpression__epsilon,

	// <generate_transactions> ~ <name> ( <trans_list> )  {NAME}
	Gr_GenerateTransactions__Name_spLPar_TransList_spRPar,

	// <generate_transactions> ~ <name>  {NAME}
	Gr_GenerateTransactions__Name,

	// <generate_transactions> ~ ? {after, every, ;, send}
	Gr_GenerateTransactions__epsilon,

	// <after_expression> ~ after <expression>  {after}
	Gr_AfterExpression__after_Expression,

	// <after_expression> ~ ? {every, ;, send}
	Gr_AfterExpression__epsilon,

	// <every_expression> ~ every <expression> <plus_minus_expression>  {every}
	Gr_EveryExpression__every_Expression_PlusMinusExpression,

	// <every_expression> ~ ? {;, send}
	Gr_EveryExpression__epsilon,

	// <plus_minus_expression> ~ +- <expression>  {+-}
	Gr_PlusMinusExpression__spPlusMinus_Expression,

	// <plus_minus_expression> ~ ? {;, send}
	Gr_PlusMinusExpression__epsilon,

	// <trans_list> ~ <name> : <expression> <trans_list_adds>  {NAME}
	Gr_TransList__Name_spColon_Expression_TransListAdds,

	// <trans_list_adds> ~ <trans_list_add> <trans_list_adds>  {;}
	Gr_TransListAdds__TransListAdd_TransListAdds,

	// <trans_list_adds> ~ ? {)}
	Gr_TransListAdds__epsilon,

	// <trans_list_add> ~ ; <name> : <expression>  {;}
	Gr_TransListAdd__spSemiCol_Name_spColon_Expression,

	// <terminate_block> ~ terminate <expression> ;  {terminate}
	Gr_TerminateBlock__terminate_Expression_spSemiCol,

	// <terminate_block> ~ terminate ;  {terminate}
	Gr_TerminateBlock__terminate_spSemiCol,

	// <advance_block> ~ advance <expression> <plus_minus_expression> ;  {advance}
	Gr_AdvanceBlock__advance_Expression_PlusMinusExpression_spSemiCol,

	// <enter_block> ~ enter <units_in_expression> <expression> <forming_expression> ;  {enter}
	Gr_EnterBlock__enter_UnitsInExpression_Expression_FormingExpression_spSemiCol,

	// <units_in_expression> ~ <expression> units in  {!, -, +, LITERAL, null, new, NAME, (}
	Gr_UnitsInExpression__Expression_units_in,

	// <units_in_expression> ~ ? {!, -, +, LITERAL, null, new, NAME, (}
	Gr_UnitsInExpression__epsilon,

	// <forming_expression> ~ forming <expression>  {forming}
	Gr_FormingExpression__forming_Expression,

	// <forming_expression> ~ ? {;, while, until}
	Gr_FormingExpression__epsilon,

	// <leave_block> ~ leave <units_from_expression> <expression> ;  {leave}
	Gr_LeaveBlock__leave_UnitsFromExpression_Expression_spSemiCol,

	// <units_from_expression> ~ <expression> units from  {!, -, +, LITERAL, null, new, NAME, (}
	Gr_UnitsFromExpression__Expression_units_from,

	// <units_from_expression> ~ ? {!, -, +, LITERAL, null, new, NAME, (}
	Gr_UnitsFromExpression__epsilon,

	// <seize_block> ~ seize <expression> <forming_expression> ;  {seize}
	Gr_SeizeBlock__seize_Expression_FormingExpression_spSemiCol,

	// <release_block> ~ release <expression> ;  {release}
	Gr_ReleaseBlock__release_Expression_spSemiCol,

	// <inqueue_block> ~ inqueue <expression> ;  {inqueue}
	Gr_InqueueBlock__inqueue_Expression_spSemiCol,

	// <outqueue_block> ~ outqueue <expression> ;  {outqueue}
	Gr_OutqueueBlock__outqueue_Expression_spSemiCol,

	// <arrive_block> ~ arrive <expression> ;  {arrive}
	Gr_ArriveBlock__arrive_Expression_spSemiCol,

	// <depart_block> ~ depart <expression> ;  {depart}
	Gr_DepartBlock__depart_Expression_spSemiCol,

	// <model_instance_block> ~ model <name> ( <arguments> ) ;  {model}
	Gr_ModelInstanceBlock__model_Name_spLPar_Arguments_spRPar_spSemiCol,

	// <model_instance_block> ~ <name> ( <arguments> ) ;  {NAME}
	Gr_ModelInstanceBlock__Name_spLPar_Arguments_spRPar_spSemiCol,

	// <goto_block> ~ goto <name> ;  {goto}
	Gr_GotoBlock__goto_Name_spSemiCol,

	// <if_block> ~ if ( <expression> ) { <model_structure> } <else_structure>  {if}
	Gr_IfBlock__if_spLPar_Expression_spRPar_spLCBrac_ModelStructure_spRCBrac_ElseStructure,

	// <wait_block> ~ wait <on_sensitivity_list> <forming_expression> <while_until> ( <expression> ) <then_structure> <else_structure> <timeout> ;  {wait}
	Gr_WaitBlock__wait_OnSensitivityList_FormingExpression_WhileUntil_spLPar_Expression_spRPar_ThenStructure_ElseStructure_Timeout_spSemiCol,

	// <on_sensitivity_list> ~ on <sensitivity_list>  {on}
	Gr_OnSensitivityList__on_SensitivityList,

	// <on_sensitivity_list> ~ ? {forming, while, until}
	Gr_OnSensitivityList__epsilon,

	// <while_until> ~ while  {while}
	Gr_WhileUntil__while,

	// <while_until> ~ until  {until}
	Gr_WhileUntil__until,

	// <then_structure> ~ then { <model_structure> }  {then}
	Gr_ThenStructure__then_spLCBrac_ModelStructure_spRCBrac,

	// <then_structure> ~ ? {else, timeout, ;}
	Gr_ThenStructure__epsilon,

	// <else_structure> ~ else { <model_structure> }  {else}
	Gr_ElseStructure__else_spLCBrac_ModelStructure_spRCBrac,

	// <else_structure> ~ ? {timeout, ;, NAME, generate, terminate, advance, enter, leave, seize, release, inqueue, outqueue, arrive, depart, model, goto, if, wait, join, create, split, gather, execute, exec, }}
	Gr_ElseStructure__epsilon,

	// <timeout> ~ timeout <expression>  {timeout}
	Gr_Timeout__timeout_Expression,

	// <timeout> ~ timeout <expression> { <model_structure> }  {timeout}
	Gr_Timeout__timeout_Expression_spLCBrac_ModelStructure_spRCBrac,

	// <timeout> ~ ? {;}
	Gr_Timeout__epsilon,

	// <sensitivity_list> ~ <name> <sensitivity_list_adds>  {NAME}
	Gr_SensitivityList__Name_SensitivityListAdds,

	// <sensitivity_list_adds> ~ <sensitivity_list_add> <sensitivity_list_adds>  {,}
	Gr_SensitivityListAdds__SensitivityListAdd_SensitivityListAdds,

	// <sensitivity_list_adds> ~ ? {forming, while, until}
	Gr_SensitivityListAdds__epsilon,

	// <sensitivity_list_add> ~ , <name>  {,}
	Gr_SensitivityListAdd__spComma_Name,

	// <join_group_block> ~ join group <expression> ;  {join}
	Gr_JoinGroupBlock__join_group_Expression_spSemiCol,

	// <leave_group_block> ~ leave group <expression> ;  {leave}
	Gr_LeaveGroupBlock__leave_group_Expression_spSemiCol,

	// <create_block> ~ create <upto_expression> <generate_transactions> <after_expression> <every_expression> <send_to> ;  {create}
	Gr_CreateBlock__create_UptoExpression_GenerateTransactions_AfterExpression_EveryExpression_SendTo_spSemiCol,

	// <send_to> ~ send to <name>  {send}
	Gr_SendTo__send_to_Name,

	// <send_to> ~ ? {;}
	Gr_SendTo__epsilon,

	// <split_block> ~ split <into_expression> <send_to> ;  {split}
	Gr_SplitBlock__split_IntoExpression_SendTo_spSemiCol,

	// <into_expression> ~ into <expression>  {into}
	Gr_IntoExpression__into_Expression,

	// <into_expression> ~ ? {send, ;}
	Gr_IntoExpression__epsilon,

	// <gather_block> ~ gather <and_destroy> <expression> ;  {gather}
	Gr_GatherBlock__gather_AndDestroy_Expression_spSemiCol,

	// <gather_block> ~ gather <and_destroy> ;  {gather}
	Gr_GatherBlock__gather_AndDestroy_spSemiCol,

	// <and_destroy> ~ and destroy  {and}
	Gr_AndDestroy__and_destroy,

	// <and_destroy> ~ ? {!, -, +, LITERAL, null, new, NAME, (, ;}
	Gr_AndDestroy__epsilon,

	// <execute_block> ~ execute { <method_body> }  {execute}
	Gr_ExecuteBlock__execute_spLCBrac_MethodBody_spRCBrac,

	// <execute_block> ~ exec { <method_body> }  {exec}
	Gr_ExecuteBlock__exec_spLCBrac_MethodBody_spRCBrac,

	// <simulation> ~ simulation NAME { <simulation_body> }  {simulation}
	Gr_Simulation__simulation_NAME_spLCBrac_SimulationBody_spRCBrac,

	// <simulation_body> ~ <simulation_stmt> <simulation_body>  {configuration, run, clear, reset}
	Gr_SimulationBody__SimulationStmt_SimulationBody,

	// <simulation_body> ~ ? {}}
	Gr_SimulationBody__epsilon,

	// <simulation_stmt> ~ <sim_configuration>  {configuration}
	Gr_SimulationStmt__SimConfiguration,

	// <simulation_stmt> ~ <sim_run>  {run}
	Gr_SimulationStmt__SimRun,

	// <simulation_stmt> ~ <sim_clear>  {clear}
	Gr_SimulationStmt__SimClear,

	// <simulation_stmt> ~ <sim_reset>  {reset}
	Gr_SimulationStmt__SimReset,

	// <sim_configuration> ~ configuration <name> ( <arguments> ) ;  {configuration}
	Gr_SimConfiguration__configuration_Name_spLPar_Arguments_spRPar_spSemiCol,

	// <sim_run> ~ run <expression> simulations <upto_expression> ;  {run}
	Gr_SimRun__run_Expression_simulations_UptoExpression_spSemiCol,

	// <sim_run> ~ run <upto_expression> ;  {run}
	Gr_SimRun__run_UptoExpression_spSemiCol,

	// <sim_clear> ~ clear ;  {clear}
	Gr_SimClear__clear_spSemiCol,

	// <sim_reset> ~ reset ;  {reset}
	Gr_SimReset__reset_spSemiCol,

	// <expression> ~ <expression2> <expression_adds>  {!, -, +, LITERAL, null, new, NAME, (}
	Gr_Expression__Expression2_ExpressionAdds,

	// <expression_adds> ~ <expression_add> <expression_adds>  {||}
	Gr_ExpressionAdds__ExpressionAdd_ExpressionAdds,

	// <expression_adds> ~ ? {,, ;, ), :, +-, forming, units, {, simulations, ], NAME, after, every, send, while, until, }}
	Gr_ExpressionAdds__epsilon,

	// <expression_add> ~ || <expression2>  {||}
	Gr_ExpressionAdd__opOr_Expression2,

	// <expression2> ~ <expression3> <expression2_adds>  {!, -, +, LITERAL, null, new, NAME, (}
	Gr_Expression2__Expression3_Expression2Adds,

	// <expression2_adds> ~ <expression2_add> <expression2_adds>  {^^}
	Gr_Expression2Adds__Expression2Add_Expression2Adds,

	// <expression2_adds> ~ ? {||, ,, ;, ), :, +-, forming, units, {, simulations, ], NAME, after, every, send, while, until, }}
	Gr_Expression2Adds__epsilon,

	// <expression2_add> ~ ^^ <expression3>  {^^}
	Gr_Expression2Add__opXor_Expression3,

	// <expression3> ~ <expression4> <expression3_adds>  {!, -, +, LITERAL, null, new, NAME, (}
	Gr_Expression3__Expression4_Expression3Adds,

	// <expression3_adds> ~ <expression3_add> <expression3_adds>  {&&}
	Gr_Expression3Adds__Expression3Add_Expression3Adds,

	// <expression3_adds> ~ ? {^^, ||, ,, ;, ), :, +-, forming, units, {, simulations, ], NAME, after, every, send, while, until, }}
	Gr_Expression3Adds__epsilon,

	// <expression3_add> ~ && <expression4>  {&&}
	Gr_Expression3Add__opAnd_Expression4,

	// <expression4> ~ <expression5>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression4__Expression5,

	// <expression4> ~ ! <expression4>  {!}
	Gr_Expression4__opNot_Expression4,

	// <expression5> ~ <expression6>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression5__Expression6,

	// <expression5> ~ <expression6> < <expression6>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression5__Expression6_opLess_Expression6,

	// <expression5> ~ <expression6> > <expression6>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression5__Expression6_opGreat_Expression6,

	// <expression5> ~ <expression6> <= <expression6>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression5__Expression6_opLessEq_Expression6,

	// <expression5> ~ <expression6> >= <expression6>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression5__Expression6_opGreatEq_Expression6,

	// <expression5> ~ <expression6> == <expression6>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression5__Expression6_opEq_Expression6,

	// <expression5> ~ <expression6> != <expression6>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression5__Expression6_opNotEq_Expression6,

	// <expression6> ~ <expression7> <expression6_adds>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression6__Expression7_Expression6Adds,

	// <expression6_adds> ~ <expression6_add> <expression6_adds>  {+, -}
	Gr_Expression6Adds__Expression6Add_Expression6Adds,

	// <expression6_adds> ~ ? {<, >, <=, >=, ==, !=, &&, ^^, ||, ,, ;, ), :, +-, forming, units, {, simulations, ], NAME, after, every, send, while, until, }}
	Gr_Expression6Adds__epsilon,

	// <expression6_add> ~ + <expression7>  {+}
	Gr_Expression6Add__opAdd_Expression7,

	// <expression6_add> ~ - <expression7>  {-}
	Gr_Expression6Add__opSub_Expression7,

	// <expression7> ~ <expression8> <expression7_adds>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression7__Expression8_Expression7Adds,

	// <expression7_adds> ~ <expression7_add> <expression7_adds>  {*, /, %}
	Gr_Expression7Adds__Expression7Add_Expression7Adds,

	// <expression7_adds> ~ ? {+, -, <, >, <=, >=, ==, !=, &&, ^^, ||, ,, ;, ), :, +-, forming, units, {, simulations, ], NAME, after, every, send, while, until, }}
	Gr_Expression7Adds__epsilon,

	// <expression7_add> ~ * <expression8>  {*}
	Gr_Expression7Add__opMul_Expression8,

	// <expression7_add> ~ / <expression8>  {/}
	Gr_Expression7Add__opDiv_Expression8,

	// <expression7_add> ~ % <expression8>  {%}
	Gr_Expression7Add__opMod_Expression8,

	// <expression8> ~ <expression9>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression8__Expression9,

	// <expression8> ~ <expression9> ^ <expression8>  {-, +, LITERAL, null, new, NAME, (}
	Gr_Expression8__Expression9_opExp_Expression8,

	// <expression9> ~ <value>  {LITERAL, null, new, NAME, (}
	Gr_Expression9__Value,

	// <expression9> ~ - <expression9>  {-}
	Gr_Expression9__opSub_Expression9,

	// <expression9> ~ + <expression9>  {+}
	Gr_Expression9__opAdd_Expression9,

	// <name> ~ NAME <name_add>  {NAME}
	Gr_Name__NAME_NameAdd,

	// <name_add> ~ <name_period_add> <name_add>  {.}
	Gr_NameAdd__NamePeriodAdd_NameAdd,

	// <name_add> ~ ? {;, as, {, <, (, :, ,, instance, NAME, [, ), after, every, send, forming, while, until, ^, *, /, %, +, -, >, <=, >=, ==, !=, &&, ^^, ||, +-, units, simulations, ], }}
	Gr_NameAdd__epsilon,

	// <name_period_add> ~ . NAME  {.}
	Gr_NamePeriodAdd__spPer_NAME,

	// <value> ~ LITERAL  {LITERAL}
	Gr_Value__LITERAL,

	// <value> ~ null  {null}
	Gr_Value__null,

	// <value> ~ new <data_type> <array_definitions_size> ( <arguments> )  {new}
	Gr_Value__new_DataType_ArrayDefinitionsSize_spLPar_Arguments_spRPar,

	// <value> ~ new <data_type> <array_definitions_size> <initialisation>  {new}
	Gr_Value__new_DataType_ArrayDefinitionsSize_Initialisation,

	// <value> ~ <name> instance of <name>  {NAME}
	Gr_Value__Name_instance_of_Name,

	// <value> ~ NAME ( <arguments> )  {NAME}
	Gr_Value__NAME_spLPar_Arguments_spRPar,

	// <value> ~ ( <expression> )  {(}
	Gr_Value__spLPar_Expression_spRPar,

	// <value> ~ ( <data_type> ) <variable_value>  {(}
	Gr_Value__spLPar_DataType_spRPar_VariableValue,

	// <value> ~ <variable_value>  {NAME}
	Gr_Value__VariableValue,

	// <value> ~ <variable_value> . NAME ( <arguments> )  {NAME}
	Gr_Value__VariableValue_spPer_NAME_spLPar_Arguments_spRPar,

	// <variable_value> ~ <name_ambiguous> <array_definitions_size> <variable_value_add>  {NAME}
	Gr_VariableValue__NameAmbiguous_ArrayDefinitionsSize_VariableValueAdd,

	// <variable_value_add> ~ <period_variable_value> <variable_value_add>  {.}
	Gr_VariableValueAdd__PeriodVariableValue_VariableValueAdd,

	// <variable_value_add> ~ ? {=, ., ^, *, /, %, +, -, <, >, <=, >=, ==, !=, &&, ^^, ||, ,, ;, ), :, +-, forming, units, {, simulations, ], NAME, after, every, send, while, until, }}
	Gr_VariableValueAdd__epsilon,

	// <period_variable_value> ~ . <variable_value>  {.}
	Gr_PeriodVariableValue__spPer_VariableValue,

	// <name_ambiguous> ~ NAME <name_add_ambiguous>  {NAME}
	Gr_NameAmbiguous__NAME_NameAddAmbiguous,

	// <name_add_ambiguous> ~ <name_period_add> <name_add_ambiguous>  {.}
	Gr_NameAddAmbiguous__NamePeriodAdd_NameAddAmbiguous,

	// <name_add_ambiguous> ~ ? {[, ., =, ^, *, /, %, +, -, <, >, <=, >=, ==, !=, &&, ^^, ||, ,, ;, ), :, +-, forming, units, {, simulations, ], NAME, after, every, send, while, until, }}
	Gr_NameAddAmbiguous__epsilon,

	// <initialisation> ~ { <initial_values> }  {{}
	Gr_Initialisation__spLCBrac_InitialValues_spRCBrac,

	// <initialisation> ~ ? {^, *, /, %, +, -, <, >, <=, >=, ==, !=, &&, ^^, ||, ,, ;, ), :, +-, forming, units, {, simulations, ], NAME, after, every, send, while, until, }}
	Gr_Initialisation__epsilon,

	// <initial_values> ~ <initial_value> <initial_value_add>  {{, !, -, +, LITERAL, null, new, NAME, (}
	Gr_InitialValues__InitialValue_InitialValueAdd,

	// <initial_values> ~ ? {}}
	Gr_InitialValues__epsilon,

	// <initial_value_add> ~ <initial_value_comma> <initial_value_add>  {,}
	Gr_InitialValueAdd__InitialValueComma_InitialValueAdd,

	// <initial_value_add> ~ ? {}}
	Gr_InitialValueAdd__epsilon,

	// <initial_value> ~ { <initial_values> }  {{}
	Gr_InitialValue__spLCBrac_InitialValues_spRCBrac,

	// <initial_value> ~ <expression>  {!, -, +, LITERAL, null, new, NAME, (}
	Gr_InitialValue__Expression,

	// <initial_value_comma> ~ , <initial_value>  {,}
	Gr_InitialValueComma__spComma_InitialValue,

	// <array_definitions_size> ~ <array_definition_size> <array_definitions_size>  {[}
	Gr_ArrayDefinitionsSize__ArrayDefinitionSize_ArrayDefinitionsSize,

	// <array_definitions_size> ~ ? {(, {, ., ^, *, /, %, +, -, <, >, <=, >=, ==, !=, &&, ^^, ||, ,, ;, ), :, +-, forming, units, simulations, ], NAME, after, every, send, while, until, =, }}
	Gr_ArrayDefinitionsSize__epsilon,

	// <array_definition_size> ~ [ <expression> ]  {[}
	Gr_ArrayDefinitionSize__spLSBrac_Expression_spRSBrac
};


class SyntaxTreeNode {
public:
	SyntaxTreeNode();
	virtual ~SyntaxTreeNode();

	Grammar Production;
	int LexUnitID;  // -1 za produkcije, >= 0 za zavrsne znakove
	GenericTable<SyntaxTreeNode> * Nodes;
	SyntaxTreeNode * Parent;
};


class AbstractSyntaxTree {
public:
	AbstractSyntaxTree();
	~AbstractSyntaxTree();
	SyntaxTreeNode *RootNode;

	void AttachParentsToChildren();
	static const char * ConvertProductionToString(Grammar p);
private:
	// something else
	void ConnectChildren(SyntaxTreeNode * parent);
};



#endif

